import { IPoint, ICircle, IVector } from "../Interfaces/IRole";
/**数学公式转换工具 */
export default class MathTools {
  /**两点坐标距离 */
  public static distancePoint(src: IPoint, des: IPoint): number {
    return Math.sqrt(
      (des.x - src.x) * (des.x - src.x) + (des.y - src.y) * (des.y - src.y)
    );
  }
  /**弧度转角度 */
  public static R2A(r: number): number {
    return (r * 180) / Math.PI;
  }
  /**角度转弧度 */
  public static A2R(a: number): number {
    return (a * Math.PI) / 180;
  }
  /**
   * 线距离转角度,非弧度
   * TIPS: x-x1 表示 x1走向x的角度
   */
  public static L2R(x: number, y: number): number {
    return this.R2A(Math.atan2(y, x));
  }
  /**
   *  距离平方
   * @param src 起始坐标
   * @param des 终点坐标
   */
  public static distancePointSquaure(start: IPoint, end: IPoint): number {
    return Math.abs(Math.sqrt(end.x - start.x) + Math.sqrt(end.y - start.y));
  }
  /**
   * 坐标的是否包含圆内
   * @param target 目标坐标
   * @param circle 圆属性
   */
  public static isInCircle(target: IPoint, circle: ICircle): Boolean {
    return (
      this.distancePointSquaure(target, { x: circle.x, y: circle.y }) <=
      circle.r * circle.r
    );
  }
  /**
   *  两圆是否相交
   * @param one 圆一
   * @param two 圆二
   */
  public static isIntersectCircle(one: ICircle, two: ICircle) {
    //公式说明 -根据圆心距与半径之和（差）对比。
    var distance = this.distancePointSquaure(
      { x: one.x, y: one.y },
      { x: two.x, y: two.y }
    );
    return distance >= two.r - one.r && distance <= two.r + one.r;
  }
  /**
   * 判断是否扇形内
   * @param pos 目标坐标
   * @param center 中心点
   * @param objAngle 对象角度
   * @param radius 半径
   * @param degree 弧度
   */
  public static isInScector(
    pos: IPoint,
    center: IPoint,
    objAngle: number,
    radius: number,
    degree: number
  ): Boolean {
    if (this.distancePointSquaure(pos, center) > radius * radius) return false;

    var angle2: number = this.L2R(pos.x - center.x, pos.y - center.y);
    return Math.abs(objAngle - angle2) <= degree * 0.5;
  }
  /**
   *  弹力向量计算
   * @param one 圆一
   * @param two 圆二
   * @param elastica 反弹系数
   * @returns 返回弹力夹角
   */
  public static vectorElasticaCompute(
    one: IVector,
    two: IVector,
    elastica: number
  ): number {
    var x = two.x - one.x * elastica;
    var y = two.y - one.y * elastica;
    return Math.atan2(y, x);
  }
//   /**
//    * 世界坐标到目标对象局部坐标
//    * @param worldPos
//    * @param target
//    * @return
//    *
//    */
// //   public static worldToLocal(worldPos: Vector3, target: Laya.Transform3D): Vector3 {
// //       var localPos: Vector3 = new Vector3();
// //       var offset: number = 0;
// //       var matrixInvert: Laya.Matrix4x4 = new Laya.Matrix4x4();
// //       target.worldMatrix.invert(matrixInvert);
// //       Laya.Utils3D.transformVector3ArrayToVector3ArrayCoordinate(localPos.elements, 0, matrixInvert, worldPos.elements, offset);
// //       return localPos;
// //   }

//   /**
//    * 转换2D屏幕坐标系统到3D投影坐标系统（仅限于正交投影）
//    * @param	source 源坐标。
//    * @param	out 输出坐标。
//    */
//   // public static screenCoordTo3DCoord(source: Vector3, out: Vector3): void {
//   //     var se = source.elements;
//   //     var oe = out.elements;
//   //     oe[0] = ((-AZConfig.deviceW >> 1) + se[0]) * AZConfig.unitPerPixel;
//   //     oe[1] = ((AZConfig.deviceH >> 1) - se[1]) * AZConfig.unitPerPixel;
//   //     oe[2] = se[2];
//   // }
}
